
/**
 * @description Rsd.cqrs.MajorSub服务介于数据通讯层和UI交互层中间
 * @description 处理 主从结构关系 的数据对象的CURD操作,不负责处理页面状态及页面交互
 */
Rsd.define('Rsd.cqrs.MajorSub', {
    extend: 'Rsd.common.Object',
    requires: ['Rsd.data.Service'],
    xtype: 'cqrs-major-sub',
    /**
     * @description （需要在view中设置的属性）获取主表单个记录的API接口服务名称
     */
    //view.major.getServiceName:'',
    /**
     * @description （需要在view中设置的属性）保存主表记录的API接口服务名称
     */
    //view.major.saveServiceName:'',
    /***
     * @description （需要在view中设置的属性）获取从表列表的API接口服务名称
     */
    //view.sub.list.ServiceName:'',
    /**
     * @description （需要在view中设置的属性）保存从表对象的API接口服务名称
     */
    //view.sub.saveServiceName:'',
    /**
     * @description （需要在view中设置的属性）删除从表对象的API接口服务名称
     */
    //sub.delete.ServiceName:'',
    /**
     * 该对象所属页面
     */
    owner: null,
    /**
    * 
    * */
    constructor: function CQRSSMajorSub(config) {
        config = config || {};
        this.apply(config);

    },
    /**
     * 
     * @param {*} majorSub 
     * @returns 
     */
    getMajorSchema: function getMajorSchema(majorSub, callback) {
        var me = this;
        if (me.majorSchema) {
            return;
        }
        var _view = me.owner;
        var _form = majorSub.items[0];
        var _majorModelType = _view.major.modelType;

        Rsd.app.getSchema(_majorModelType, function (schema) {

            var _fields = _view.major.fields || [];
            try {

                if (schema) {
                    
                    me.majorSchema = schema;

                    if (_fields.length === 0) {
                        _fields = schema.getFields();
                    }
                }
                else {
                    console.error('未找到类型：' + _majorModelType + '的Schema对象');
                }

                var w = _view.major.labelWidth || 0;
                if (w) 
                {
                    for (var i in _fields) {
                        //_fields[i].required = true;
                        if (_fields[i].label) {
                            _fields[i].label.width = w;
                        }
                    }
                }

                var _hiddens = [];
                _hiddens.push({ xtype: 'hidden', name: 'modelType', value:_majorModelType});
                _hiddens.push({ xtype: 'hidden', name: '___key', value: Rsd.getAppToken() });
                //合并
                _form.fields = Rsd.arrayConcat(_fields, _hiddens);

            } catch (ex) {
                Rsd.error('加载模型结构失败', ex);
            }

            if (callback) {
                callback();
            }
        });
    },
    /**
     * 
     * @param {*} majorSub 
     * @param {*} callback 
     * @returns 
     */
    getSubSchema: function getSubSchema(majorSub, callback) {
        var me = this;
        if (me.subSchema) {
            return;
        }
        var _view = me.owner;
        var _grid = majorSub.items[1];
        var _subModelType = _view.sub.modelType;

        Rsd.app.getSchema(_subModelType, function (schema) {

            try {
                if (schema) {

                    me.subSchema = schema; 
                    if(_view.sub.columns.length ==0)
                    {
                        var _cols = Rsd.arrayConcat(schema.getColumns(), majorSub.opColumns||[]);  
                        
                        if(_grid instanceof Rsd.control.Grid)
                        {
                            _grid.buildColumns(_cols);
                            return;
                        }
                      
                        if(_grid instanceof  Object)
                        {
                            _grid.columns = _cols;
                        } 
                    }
                     
                }
                else {
                    console.error('未找到类型：' + me.modelType + '的Schema对象');
                }

            } catch (ex) {
                Rsd.error('加载模型结构失败', ex);
            }

            if (callback) {
                callback();
            }
        });
    },
    /**
     * @description 【数据流方向-向下】从接口获取数据，并加载到控件 
     * @param {*} majorSub 
     * @param {*} callback 
     */
    getMajor: function getMajor(majorSub, callback) {
        var me = this;
        var _view = me.owner;
        var _form = majorSub.items[0];
        //var _majorModelType = _view.major.modelType;
        //
        //console.error('未实现');
        var _key = _view.key;

        me.majorSchema.findObject(_key,function(resp){
           
            _form.loadRecord(resp.data);
            if(callback)
            {
                callback(resp.data);
            }    
        });
    },
    /**
     * @description 【数据流方向-向上】从控件获取数据，并提交接口保存 
     * @param {*} majorSub 
     */
    saveMajor: function saveMajor(majorSub, callback) {
        var me = this;
        var _view = me.owner;
        var _form = majorSub.items[0];
        var _majorModelType = _view.major.modelType;

        if (_view.readonly) {
            Rsd.alert('当前页面仅有只读权限。');
            return;
        }
        //有效性检查
        if (_form.checkRecord() == false) {
            _form.showError();
            return;
        }

        var _record = _form.getRecord();

        if (_record == null) {
            Rsd.msg("数据错误，无法保存。");
            return;
        }
        //指定方法
        if (_view.major.saveHandler) {

            _view.funApplyByIOC(_view.major.saveHandler,[_record,callback]);
            
            return;
        }

        //指定接口服务
        if (_view.major.saveServiceName) {
            Rsd.app.getService(_viewme.major.saveServiceName).request(_record, function (resp) {

                if (resp.success) {

                    if (callback) {
                        callback(resp.data);
                    }

                    Rsd.showPopup("保存成功。");
                    return false;//flase 表示拒绝后续拦截方法的处理
                } else {
                    Rsd.alert('数据保存失败', resp.msg);
                    return false;//flase 表示拒绝后续拦截方法的处理
                }
            });

            return;
        }

        if (Rsd.isEmpty(_majorModelType)) {
            Rsd.alert("保存失败\r\nmajor.modelType属性为空。");
            return;
        }

        if (Rsd.isEmpty(me.majorSchema)) {
            Rsd.alert("保存失败\r\nSchema属性为空。");
            return;
        }
        if (me.majorSchema instanceof Rsd.data.ModelSchema) {
        }
        else {
            console.log(me.majorSchema);
            Rsd.alert("保存失败\r\nSchema错误(不是有效的Rsd.data.ModelSchema对象)。");
            return;
        }
        if (Rsd.isEmpty(me.majorSchema.keys)) {
            Rsd.msg("主键不存在，无法执行保存。");
            return;
        }
        //新增，根据主键值是否存在 判断是否是插入操作
        if (Rsd.isEmpty(_record[me.majorSchema.keys[0]])) {

            me.majorSchema.insertObject(_record, function (resp) {
                if (resp.success) {
                    
                    Rsd.showPopup("新增数据保存成功。");
                    
                    //更新主键 或重新加载（如果后端完善数据项内容） 
                    if (callback) {
                        callback(resp.data);
                    }
                    return false;
                }
                return true;
            });

            return;
        }
        //修改
        me.majorSchema.updateObject(_record, function (resp) {
            if (resp.success) {

                Rsd.showPopup("修改数据保存成功。");
                //重新加载（如果后端完善数据项内容） 
                if (callback) {
                    callback(resp.data);
                }

                return false;
            }
            return true;
        });

        return;
    },
    /**
     * @description 【数据流方向-向下】从接口获取数据，并加载到控件 
     * @param {*} majorSub 
     */
    listSub: function listSub(majorSub, callback) {
        var me = this;
        var _view = me.owner;
        var _ms = majorSub;
        var _row = _view.data;
        var _key = _view.key;
        if (_ms) {

            var _keyName = _view.major.keyName;
            var _fkName = _view.sub.fkName;
            var _type = _view.sub.modelType;
            if(Rsd.isEmpty(_keyName))
            {
                throw new Error('major keyName value is null or not undedined.');
            }
            if(Rsd.isEmpty(_fkName))
            {
                throw new Error('sub fkName value is null or not undedined.');
            }
            _key = _row[_keyName]; 

        }

        if (Rsd.isEmpty(_key)) {
            throw new Error('Key value is null or not undedined.');
        }

        setTimeout(function () {
 
            var _where = [{
                name: _fkName,
                op: 'equals',
                value: _key
            }];

            var _sort = _view.sub.sort || [{ name: 'CreateTime', direction: 'asc' }];
            var _args = { modelType: _type, where: _where, sort: _sort };
            
            //设置表格数据源
            if(!_ms.items[1].dataSource)
            { 
                _ms.items[1].dataSource = Rsd.app.getService(me.subSchema.listService);
            }
             //加载数据到表格 
             _ms.loadSub(_args,callback);
           

        }, me.subSchema?50:250);
    },
    /**
     * @description 【数据流方向-向上】提交接口删除从表对象，并从控件中删除从表对象 
     * @param {*} majorSub 
     */
    deleteSub: function deleteSub(majorSub, row, callback) {
        var me = this;
        var _view = me.owner;
        var _ms = majorSub;
        var _row = row;
        var _subModelType = _view.sub.modelType;

        //console.log(row);

        //指定方法
        if (_view.sub.deleteHandler) {
            
            _view.funApplyByIOC(_view.sub.deleteHandler,[_row,callback]);
          
            return;
        }

        //指定接口服务
        if (_view.sub.deleteServiceName) {

            Rsd.app.getService(_view.sub.deleteServiceName).request(_row, function (resp) {

                if (resp.success) {

                    if (callback) {
                        callback(resp.data);
                    }

                    Rsd.showPopup("删除成功。");
                    return false;//flase 表示拒绝后续拦截方法的处理
                } else {
                    Rsd.alert('数据删除失败', resp.msg);
                    return false;//flase 表示拒绝后续拦截方法的处理
                }
            });

            return;
        }

        if (Rsd.isEmpty(_subModelType)) {
            Rsd.alert("删除失败\r\nmajor.modelType属性为空。");
            return;
        }

        if (Rsd.isEmpty(me.subSchema)) {
            Rsd.alert("删除失败\r\nSchema属性为空。");
            return;
        }

        if (me.subSchema instanceof Rsd.data.ModelSchema) {
        }
        else {
            console.log(me.subSchema);
            Rsd.alert("删除失败\r\nSchema错误(不是有效的Rsd.data.ModelSchema对象)。");
            return;
        }

        if (Rsd.isEmpty(me.subSchema.keys)) {
            Rsd.msg("主键不存在，无法执行删除。");
            return;
        }
        //根据主键值是否存在 判断是否已保存
        if (!Rsd.isEmpty(_row[me.subSchema.keys[0]])) {

            //请求删除
            me.subSchema.deleteObject(_row, function (resp) {

                if (resp.success) {

                    Rsd.showPopup("删除成功。");
                    if (callback) {
                        callback(resp.data);
                    }
                    return false;
                }
                return true;
            });

            return;
        }
        //尚未保存，不需要请求远端
        if(callback)
        {
            callback();
        }

        return;
    },
    /**
     * @description 【数据流方向-向上】从控件获取从表数据，并提交接口保存 
     * @param {*} majorSub 
     */
    saveSub: function saveSub(majorSub, row, callback) {
        var me = this;
        var _view = me.owner;
        var _ms = majorSub;
        var _row = row;
        var _subModelType = _view.sub.modelType;
        //console.log(row); 

        //指定方法
        if (_view.sub.saveHandler) {

            _view.funApplyByIOC(_view.sub.saveHandler,[_row,callback]);
            
            return;
        }

        //指定接口服务
        if (_view.sub.saveServiceName) {

            Rsd.app.getService(_view.sub.saveServiceName).request(_row, function (resp) {

                if (resp.success) {

                    if (callback) {
                        callback(resp.data);
                    }

                    Rsd.showPopup("保存成功。");
                    return false;//flase 表示拒绝后续拦截方法的处理
                } else {
                    Rsd.alert('数据保存失败', resp.msg);
                    return false;//flase 表示拒绝后续拦截方法的处理
                }
            });

            return;
        }

        if (Rsd.isEmpty(_subModelType)) {
            Rsd.alert("保存失败\r\nmajor.modelType属性为空。");
            return;
        }

        if (Rsd.isEmpty(me.subSchema)) {
            Rsd.alert("保存失败\r\nSchema属性为空。");
            return;
        }

        if (me.subSchema instanceof Rsd.data.ModelSchema) {
        }
        else {
            console.log(me.subSchema);
            Rsd.alert("保存失败\r\nSchema错误(不是有效的Rsd.data.ModelSchema对象)。");
            return;
        }

        if (Rsd.isEmpty(me.subSchema.keys)) {
            Rsd.msg("主键不存在，无法执行保存。");
            return;
        }
        var _key = me.subSchema.keys[0];
        //新增
        if (Rsd.isEmpty(_row[_key])) {

            me.subSchema.insertObject(_row, function (resp) {

                if (resp.success) {

                    Rsd.showPopup("新增数据保存成功。");
                    //更新主键 或重新加载（如果后端完善数据项内容
                    _row[_key] = resp.data[_key];
                    if (callback) {
                        callback(resp.data);
                    }
                    return false;
                }
                return true;
            });

            return;
        }

        //修改
        me.subSchema.updateObject(_row, function (resp) {

            if (resp.success) {

                Rsd.showPopup("修改数据保存成功。");
                //重新加载（如果后端完善数据项内容

                if (callback) {
                    callback(resp.data);
                }

                return false;
            }
            return true;

        });

        return;
    }

});